home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 January / macformat-020.iso / Shareware City / Developers / OutOfPhase1.01Source / OutOfPhase Folder / BinaryCodedDecimal.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-01  |  8.7 KB  |  325 lines  |  [TEXT/KAHL]
  1. /* BinaryCodedDecimal.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #include "BinaryCodedDecimal.h"
  31. #include "DataMunging.h"
  32. #include "Memory.h"
  33.  
  34.  
  35. /* maximum string:  10 digits + 1 sign + 1 decimal */
  36. #define BCDBUFFSIZE (10 + 1 + 1)
  37.  
  38.  
  39. /* convert double precision number to small BCD number.  Rounding is towards */
  40. /* nearest. (0.4 ==> 0, 0.6 ==> 1, -0.4 ==> 0, -0.6 ==> -1) */
  41. /* value is constrained if it is out of range */
  42. SmallBCDType            Double2SmallBCD(double Value)
  43.     {
  44.         double                    CorrectedFactor;
  45.  
  46.         CorrectedFactor = (Value * SMALLBCDPRECISION) + ((Value >= 0) ? 0.5 : -0.5);
  47.         if (CorrectedFactor > 29999)
  48.             {
  49.                 return 29999;
  50.             }
  51.         else if (CorrectedFactor < -29999)
  52.             {
  53.                 return -29999;
  54.             }
  55.         else
  56.             {
  57.                 return (SmallBCDType)CorrectedFactor;
  58.             }
  59.     }
  60.  
  61.  
  62. /* convert double precision number to large BCD number. */
  63. LargeBCDType            Double2LargeBCD(double Value)
  64.     {
  65.         double                    CorrectedFactor;
  66.  
  67.         CorrectedFactor = (Value * LARGEBCDPRECISION) + ((Value >= 0) ? 0.5 : -0.5);
  68.         if (CorrectedFactor > 999999999)
  69.             {
  70.                 return 999999999;
  71.             }
  72.         else if (CorrectedFactor < -999999999)
  73.             {
  74.                 return -999999999;
  75.             }
  76.         else
  77.             {
  78.                 return (LargeBCDType)CorrectedFactor;
  79.             }
  80.     }
  81.  
  82.  
  83. /* convert double precision to small extended BCD number */
  84. SmallExtBCDType        Double2SmallExtBCD(double Value)
  85.     {
  86.         double                    CorrectedFactor;
  87.  
  88.         CorrectedFactor = (Value * SMALLEXTBCDPRECISION) + ((Value >= 0) ? 0.5 : -0.5);
  89.         if (CorrectedFactor > 999999999)
  90.             {
  91.                 return 999999999;
  92.             }
  93.         else if (CorrectedFactor < -999999999)
  94.             {
  95.                 return -999999999;
  96.             }
  97.         else
  98.             {
  99.                 return (SmallExtBCDType)CorrectedFactor;
  100.             }
  101.     }
  102.  
  103.  
  104. /* convert small BCD number to string */
  105. char*                            SmallBCDToString(SmallBCDType Number)
  106.     {
  107.         char                        Buffer[BCDBUFFSIZE];
  108.         int                            Index;
  109.         char*                        ReturnValue;
  110.  
  111.         Index = 0;
  112.         /* sign */
  113.         if (Number < 0)
  114.             {
  115.                 Buffer[Index++] = '-';
  116.                 Number = - Number;
  117.             }
  118.         /* tens */
  119.         if ((Number / 10000) != 0)
  120.             {
  121.                 Buffer[Index++] = (Number / 10000) + '0';
  122.                 Number -= (Number / 10000) * 10000;
  123.             }
  124.         /* ones */
  125.         Buffer[Index++] = (Number / 1000) + '0';
  126.         Number -= (Number / 1000) * 1000;
  127.         if (Number != 0)
  128.             {
  129.                 Buffer[Index++] = '.';
  130.                 /* tenths */
  131.                 Buffer[Index++] = (Number / 100) + '0';
  132.                 Number -= (Number / 100) * 100;
  133.                 if (Number != 0)
  134.                     {
  135.                         /* hundreths */
  136.                         Buffer[Index++] = (Number / 10) + '0';
  137.                         Number -= (Number / 10) * 10;
  138.                         if (Number != 0)
  139.                             {
  140.                                 /* thousandths */
  141.                                 Buffer[Index++] = Number + '0';
  142.                             }
  143.                     }
  144.             }
  145.         ReturnValue = BlockFromRaw(Buffer,Index);
  146.         if (ReturnValue != NIL)
  147.             {
  148.                 SetTag(ReturnValue,"SmallBCDToString");
  149.             }
  150.         return ReturnValue;
  151.     }
  152.  
  153.  
  154. /* convert large BCD number to string */
  155. char*                            LargeBCDToString(LargeBCDType Number)
  156.     {
  157.         char                        Buffer[BCDBUFFSIZE];
  158.         int                            Index;
  159.         char*                        ReturnValue;
  160.         MyBoolean                PrintedBigDigit;
  161.  
  162.         Index = 0;
  163.         PrintedBigDigit = False;
  164.         /* sign */
  165.         if (Number < 0)
  166.             {
  167.                 Buffer[Index++] = '-';
  168.                 Number = - Number;
  169.             }
  170.         /* thousands digit */
  171.         if (Number / 1000000000 != 0)
  172.             {
  173.                 Buffer[Index++] = (Number / 1000000000) + '0';
  174.                 Number -= (Number / 1000000000) * 1000000000;
  175.                 PrintedBigDigit = True;
  176.             }
  177.         /* hundreds digit */
  178.         if (PrintedBigDigit || (Number / 100000000 != 0))
  179.             {
  180.                 Buffer[Index++] = (Number / 100000000) + '0';
  181.                 Number -= (Number / 100000000) * 100000000;
  182.                 PrintedBigDigit = 0;
  183.             }
  184.         /* tens digit */
  185.         if (PrintedBigDigit || (Number / 10000000 != 0))
  186.             {
  187.                 Buffer[Index++] = (Number / 10000000) + '0';
  188.                 Number -= (Number / 10000000) * 10000000;
  189.                 PrintedBigDigit = True;
  190.             }
  191.         /* ones digit */
  192.         Buffer[Index++] = (Number / 1000000) + '0';
  193.         Number -= (Number / 1000000) * 1000000;
  194.         if (Number != 0)
  195.             {
  196.                 Buffer[Index++] = '.';
  197.                 /* tenths */
  198.                 Buffer[Index++] = (Number / 100000) + '0';
  199.                 Number -= (Number / 100000) * 100000;
  200.                 if (Number != 0)
  201.                     {
  202.                         /* hundreths */
  203.                         Buffer[Index++] = (Number / 10000) + '0';
  204.                         Number -= (Number / 10000) * 10000;
  205.                         if (Number != 0)
  206.                             {
  207.                                 /* thousandths */
  208.                                 Buffer[Index++] = (Number / 1000) + '0';
  209.                                 Number -= (Number / 1000) * 1000;
  210.                                 if (Number != 0)
  211.                                     {
  212.                                         /* ten-thousandths */
  213.                                         Buffer[Index++] = (Number / 100) + '0';
  214.                                         Number -= (Number / 100) * 100;
  215.                                         if (Number != 0)
  216.                                             {
  217.                                                 /* hundred-thousandths */
  218.                                                 Buffer[Index++] = (Number / 10) + '0';
  219.                                                 Number -= (Number / 10) * 10;
  220.                                                 if (Number != 0)
  221.                                                     {
  222.                                                         /* millionths */
  223.                                                         Buffer[Index++] = Number + '0';
  224.                                                     }
  225.                                             }
  226.                                     }
  227.                             }
  228.                     }
  229.             }
  230.         ReturnValue = BlockFromRaw(Buffer,Index);
  231.         if (ReturnValue != NIL)
  232.             {
  233.                 SetTag(ReturnValue,"LargeBCDToString");
  234.             }
  235.         return ReturnValue;
  236.     }
  237.  
  238.  
  239. /* convert small extended BCD number to string */
  240. char*                            SmallExtBCDToString(SmallExtBCDType Number)
  241.     {
  242.         char                        Buffer[BCDBUFFSIZE];
  243.         int                            Index;
  244.         char*                        ReturnValue;
  245.         MyBoolean                PrintedBigDigit;
  246.  
  247.         Index = 0;
  248.         PrintedBigDigit = False;
  249.         /* sign */
  250.         if (Number < 0)
  251.             {
  252.                 Buffer[Index++] = '-';
  253.                 Number = - Number;
  254.             }
  255.         /* millions digit */
  256.         if (Number / 1000000000 != 0)
  257.             {
  258.                 Buffer[Index++] = (Number / 1000000000) + '0';
  259.                 Number -= (Number / 1000000000) * 1000000000;
  260.                 PrintedBigDigit = True;
  261.             }
  262.         /* hundred-thousands digit */
  263.         if (PrintedBigDigit || (Number / 100000000 != 0))
  264.             {
  265.                 Buffer[Index++] = (Number / 100000000) + '0';
  266.                 Number -= (Number / 100000000) * 100000000;
  267.                 PrintedBigDigit = 0;
  268.             }
  269.         /* ten-thousands digit */
  270.         if (PrintedBigDigit || (Number / 10000000 != 0))
  271.             {
  272.                 Buffer[Index++] = (Number / 10000000) + '0';
  273.                 Number -= (Number / 10000000) * 10000000;
  274.                 PrintedBigDigit = True;
  275.             }
  276.         /* thousands digit */
  277.         if (PrintedBigDigit || (Number / 1000000 != 0))
  278.             {
  279.                 Buffer[Index++] = (Number / 1000000) + '0';
  280.                 Number -= (Number / 1000000) * 1000000;
  281.                 PrintedBigDigit = True;
  282.             }
  283.         /* hundreds digit */
  284.         if (PrintedBigDigit || (Number / 100000 != 0))
  285.             {
  286.                 Buffer[Index++] = (Number / 100000) + '0';
  287.                 Number -= (Number / 100000) * 100000;
  288.                 PrintedBigDigit = True;
  289.             }
  290.         /* tens digit */
  291.         if (PrintedBigDigit || (Number / 10000 != 0))
  292.             {
  293.                 Buffer[Index++] = (Number / 10000) + '0';
  294.                 Number -= (Number / 10000) * 10000;
  295.                 PrintedBigDigit = True;
  296.             }
  297.         /* ones digit */
  298.         Buffer[Index++] = (Number / 1000) + '0';
  299.         Number -= (Number / 1000) * 1000;
  300.         if (Number != 0)
  301.             {
  302.                 Buffer[Index++] = '.';
  303.                 /* tenths */
  304.                 Buffer[Index++] = (Number / 100) + '0';
  305.                 Number -= (Number / 100) * 100;
  306.                 if (Number != 0)
  307.                     {
  308.                         /* hundreths */
  309.                         Buffer[Index++] = (Number / 10) + '0';
  310.                         Number -= (Number / 10) * 10;
  311.                         if (Number != 0)
  312.                             {
  313.                                 /* thousandths */
  314.                                 Buffer[Index++] = Number + '0';
  315.                             }
  316.                     }
  317.             }
  318.         ReturnValue = BlockFromRaw(Buffer,Index);
  319.         if (ReturnValue != NIL)
  320.             {
  321.                 SetTag(ReturnValue,"SmallExtBCDToString");
  322.             }
  323.         return ReturnValue;
  324.     }
  325.